package com.wzy.crm.wx.cp.utils;

import com.wzy.crm.wx.cp.utils.wechat.AccessToken;
import com.wzy.crm.wx.cp.utils.wechat.JSTicket;
import com.wzy.crm.wx.cp.utils.wechat.OAuthAccessToken;
import org.apache.commons.lang3.StringUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class WxMemoryCacheClient {

    //服务器内存的方式缓存 accessToken、jsTicket
    private static Map<String,AccessToken> accountAccessTokenMap = new ConcurrentHashMap<String,AccessToken>();
    private static Map<String,JSTicket> accountJSTicketMap = new ConcurrentHashMap<String,JSTicket>();

    //微信OAuth认证的时候，服务器内存的方式缓存openid; key=sessionid ，value=openid
    private static Map<String,String> sessionOpenIdMap = new HashMap<String,String>();
    private static Map<String,OAuthAccessToken> accountOAuthTokenMap = new HashMap<String,OAuthAccessToken>();

    public static AccessToken addAccessToken(String agentId ,AccessToken token){
        if(token != null){
            accountAccessTokenMap.put(agentId, token);
        }
        return token;
    }

    /**
     * accessToken的获取，绝对不要从缓存中直接获取，请从WxApiClient中获取；
     * @param agentId
     * @return
     */
    public static AccessToken getAccessToken(String agentId){
        return accountAccessTokenMap.get(agentId);
    }

    /**
     * 获取唯一的公众号的accessToken,如果需要多账号，请自行处理
     * accessToken的获取，绝对不要从缓存中直接获取，请从WxApiClient中获取；
     * @return
     */
    public static AccessToken getSingleAccessToken(){
        AccessToken accessToken = null;
        for(String key : accountAccessTokenMap.keySet()){
            accessToken = accountAccessTokenMap.get(key);
            break;
        }
        return accessToken;
    }

    /**
     * 添加JSTicket到缓存
     * @param agentId
     * @param jsTicket
     * @return
     */
    public static JSTicket addJSTicket(String agentId ,JSTicket jsTicket){
        if(jsTicket != null){
            accountJSTicketMap.put(agentId, jsTicket);
        }
        return jsTicket;
    }

    /**
     * JSTicket的获取，绝对不要从缓存中直接获取，请从JSTicket中获取；
     * @param account
     * @return
     */
    public static JSTicket getJSTicket(String account){
        return accountJSTicketMap.get(account);
    }

    /**
     * 获取唯一的公众号的JSTicket,如果需要多账号，请自行处理
     * JSTicket的获取，绝对不要从缓存中直接获取，请从WxApiClient中获取；
     * @return
     */
    public static JSTicket getSingleJSTicket(){
        JSTicket jsTicket = null;
        for(String key : accountJSTicketMap.keySet()){
            jsTicket = accountJSTicketMap.get(key);
            break;
        }
        return jsTicket;
    }


    //处理openid缓存
    public static String getOpenid(String sessionid){
        if(!StringUtils.isBlank(sessionid)){
            return sessionOpenIdMap.get(sessionid);
        }
        return null;
    }

    public static String setOpenid(String sessionid, String openid){
        if(!StringUtils.isBlank(sessionid) && !StringUtils.isBlank(openid)){
            sessionOpenIdMap.put(sessionid, openid);
        }
        return openid;
    }

    //处理OAuth的Token
    public static AccessToken addOAuthAccessToken(String account ,OAuthAccessToken token){
        if(token != null){
            accountOAuthTokenMap.put(account, token);
        }
        return token;
    }

    /**
     * OAuthAccessToken的获取，绝对不要从缓存中直接获取，请从WxApiClient中获取；
     * @param account
     * @return
     */
    public static OAuthAccessToken getOAuthAccessToken(String account){
        return accountOAuthTokenMap.get(account);
    }

    /**
     * 获取唯一的公众号的accessToken,如果需要多账号，请自行处理
     * OAuthAccessToken的获取，绝对不要从缓存中直接获取，请从WxApiClient中获取；
     * @return
     */
    public static OAuthAccessToken getSingleOAuthAccessToken(){
        OAuthAccessToken token = null;
        for(String key : accountOAuthTokenMap.keySet()){
            token = accountOAuthTokenMap.get(key);
            break;
        }
        return token;
    }

}
